package View.CoolSwing;

/*
 * @(#)DefaultTreeCellRenderer.java	1.61 07/01/08
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
import javax.swing.*;
import javax.swing.plaf.ColorUIResource;
import javax.swing.plaf.FontUIResource;
import javax.swing.tree.TreeCellRenderer;

import java.awt.*;
import java.awt.image.BufferedImage;

public class DefaultTreeCellRenderer extends JLabel implements TreeCellRenderer
{
	/**
	 * serialVersionUID
	 */
	private static final long serialVersionUID = 7800010981684158374L;
	/**
	 * Added by zmm,and used in "Paint(Graphics g)";
	 */
    private static final Color COLOR1 	= new Color(125, 161, 237,126);
    private static final Color COLOR2 	= new Color(91, 118, 173);
    private BufferedImage bufferedImage = null;
    
    /** Last tree the renderer was painted in. */
    private JTree tree;

    /** Is the value currently selected. */
    protected boolean selected;
    /** True if has focus. */
    protected boolean hasFocus;
    /** True if draws focus border around icon as well. */
    private boolean drawsFocusBorderAroundIcon;
    /** If true, a dashed line is drawn as the focus indicator. */
    private boolean drawDashedFocusIndicator;
    
    // If drawDashedFocusIndicator is true, the following are used.
    /**
     * Background color of the tree.
     */
    private Color treeBGColor;
    /**
     * Color to draw the focus indicator in, determined from the background.
     * color.
     */
    private Color focusBGColor;

    // Icons
    /** Icon used to show non-leaf nodes that aren't expanded. */
    transient protected Icon closedIcon;

    /** Icon used to show leaf nodes. */
    transient protected Icon leafIcon;

    /** Icon used to show non-leaf nodes that are expanded. */
    transient protected Icon openIcon;

    // Colors
    /** Color to use for the foreground for selected nodes. */
    protected Color textSelectionColor;

    /** Color to use for the foreground for non-selected nodes. */
    protected Color textNonSelectionColor;

    /** Color to use for the background when a node is selected. */
    protected Color backgroundSelectionColor;

    /** Color to use for the background when the node isn't selected. */
    protected Color backgroundNonSelectionColor;

    /** Color to use for the focus indicator when the node has focus. */
    protected Color borderSelectionColor;

    private boolean isDropCell;

    /**
      * Returns a new instance of DefaultTreeCellRenderer.  Alignment is
      * set to left aligned. Icons and text color are determined from the
      * UIManager.
      */
    public DefaultTreeCellRenderer() {
//    	setOpaque(false);
		setLeafIcon(UIManager.getIcon("Tree.leafIcon"));
		setClosedIcon(UIManager.getIcon("Tree.closedIcon"));
		setOpenIcon(UIManager.getIcon("Tree.openIcon"));
	
		setTextSelectionColor(UIManager.getColor("Tree.selectionForeground"));
		setTextNonSelectionColor(UIManager.getColor("Tree.textForeground"));
		setBackgroundSelectionColor(UIManager.getColor("Tree.selectionBackground"));
		setBackgroundNonSelectionColor(UIManager.getColor("Tree.textBackground"));
		setBorderSelectionColor(UIManager.getColor("Tree.selectionBorderColor"));
		Object value = UIManager.get("Tree.drawsFocusBorderAroundIcon");
		drawsFocusBorderAroundIcon = (value != null && ((Boolean)value).
					      booleanValue());
		value = UIManager.get("Tree.drawDashedFocusIndicator");
		drawDashedFocusIndicator = (value != null && ((Boolean)value).
					    booleanValue());
    }


    /**
      * Returns the default icon, for the current laf, that is used to
      * represent non-leaf nodes that are expanded.
      */
    public Icon getDefaultOpenIcon() {
		return UIManager.getIcon("Tree.openIcon");	
    }

    /**
      * Returns the default icon, for the current laf, that is used to
      * represent non-leaf nodes that are not expanded.
      */
    public Icon getDefaultClosedIcon() {
		return UIManager.getIcon("Tree.closedIcon");
    }

    /**
      * Returns the default icon, for the current laf, that is used to
      * represent leaf nodes.
      */
    public Icon getDefaultLeafIcon() {
		return UIManager.getIcon("Tree.leafIcon");
    }

    /**
      * Sets the icon used to represent non-leaf nodes that are expanded.
      */
    public void setOpenIcon(Icon newIcon) {
		openIcon = newIcon;
    }

    /**
      * Returns the icon used to represent non-leaf nodes that are expanded.
      */
    public Icon getOpenIcon() {
		return openIcon;
    }

    /**
      * Sets the icon used to represent non-leaf nodes that are not expanded.
      */
    public void setClosedIcon(Icon newIcon) {
		closedIcon = newIcon;
    }

    /**
      * Returns the icon used to represent non-leaf nodes that are not
      * expanded.
      */
    public Icon getClosedIcon() {
		return closedIcon;
    }

    /**
      * Sets the icon used to represent leaf nodes.
      */
    public void setLeafIcon(Icon newIcon) {
		leafIcon = newIcon;
    }

    /**
      * Returns the icon used to represent leaf nodes.
      */
    public Icon getLeafIcon() {
		return leafIcon;
    }

    /**
      * Sets the color the text is drawn with when the node is selected.
      */
    public void setTextSelectionColor(Color newColor) {
		textSelectionColor = newColor;
    }

    /**
      * Returns the color the text is drawn with when the node is selected.
      */
    public Color getTextSelectionColor() {
		return textSelectionColor;
    }

    /**
      * Sets the color the text is drawn with when the node isn't selected.
      */
    public void setTextNonSelectionColor(Color newColor) {
		textNonSelectionColor = newColor;
    }

    /**
      * Returns the color the text is drawn with when the node isn't selected.
      */
    public Color getTextNonSelectionColor() {
		return textNonSelectionColor;
    }

    /**
      * Sets the color to use for the background if node is selected.
      */
    public void setBackgroundSelectionColor(Color newColor) {
		backgroundSelectionColor = newColor;
    }


    /**
      * Returns the color to use for the background if node is selected.
      */
    public Color getBackgroundSelectionColor() {
		return backgroundSelectionColor;
    }

    /**
      * Sets the background color to be used for non selected nodes.
      */
    public void setBackgroundNonSelectionColor(Color newColor) {
		backgroundNonSelectionColor = newColor;
    }

    /**
      * Returns the background color to be used for non selected nodes.
      */
    public Color getBackgroundNonSelectionColor() {
		return backgroundNonSelectionColor;
    }

    /**
      * Sets the color to use for the border.
      */
    public void setBorderSelectionColor(Color newColor) {
		borderSelectionColor = newColor;
    }

    /**
      * Returns the color the border is drawn.
      */
    public Color getBorderSelectionColor() {
		return borderSelectionColor;
    }

    /**
     * Subclassed to map <code>FontUIResource</code>s to null. If 
     * <code>font</code> is null, or a <code>FontUIResource</code>, this
     * has the effect of letting the font of the JTree show
     * through. On the other hand, if <code>font</code> is non-null, and not
     * a <code>FontUIResource</code>, the font becomes <code>font</code>.
     */
    public void setFont(Font font) {
		if(font instanceof FontUIResource)
		    font = null;
		super.setFont(font);
    }

    /**
     * Gets the font of this component.
     * @return this component's font; if a font has not been set
     * for this component, the font of its parent is returned
     */
    public Font getFont() {
        Font font = super.getFont();

        if (font == null && tree != null) {
            // Strive to return a non-null value, otherwise the html support
            // will typically pick up the wrong font in certain situations.
            font = tree.getFont();
        }
        return font;
    }

    /**
     * Subclassed to map <code>ColorUIResource</code>s to null. If 
     * <code>color</code> is null, or a <code>ColorUIResource</code>, this
     * has the effect of letting the background color of the JTree show
     * through. On the other hand, if <code>color</code> is non-null, and not
     * a <code>ColorUIResource</code>, the background becomes
     * <code>color</code>.
     */
    public void setBackground(Color color) {
		if(color instanceof ColorUIResource)
		    color = null;
		super.setBackground(color);
    }

    /**
      * Configures the renderer based on the passed in components.
      * The value is set from messaging the tree with
      * <code>convertValueToText</code>, which ultimately invokes
      * <code>toString</code> on <code>value</code>.
      * The foreground color is set based on the selection and the icon
      * is set based on the <code>leaf</code> and <code>expanded</code>
      * parameters.
      */
    public Component getTreeCellRendererComponent(JTree tree, Object value,
												  boolean sel,
												  boolean expanded,
												  boolean leaf, int row,
												  boolean hasFocus) {
		String  stringValue = tree.convertValueToText(value, sel,
						  							expanded, leaf, row, hasFocus);
	    this.tree = tree;
		this.hasFocus = hasFocus;
		setText(stringValue);

        Color fg = null;
        isDropCell = false;

        JTree.DropLocation dropLocation = tree.getDropLocation();
        if (dropLocation != null
                && dropLocation.getChildIndex() == -1
                && tree.getRowForPath(dropLocation.getPath()) == row) {

            Color col = UIManager.getColor("Tree.dropCellForeground");
            if (col != null) {
                fg = col;
            } else {
                fg = getTextSelectionColor();
            }

            isDropCell = true;
        } else if (sel) {
            fg = getTextSelectionColor();
        } else {
            fg = getTextNonSelectionColor();
        }

        setForeground(fg);

		// There needs to be a way to specify disabled icons.
		if (!tree.isEnabled()) {
		    setEnabled(false);
		    if (leaf) {
			setDisabledIcon(getLeafIcon());
		    } else if (expanded) {
			setDisabledIcon(getOpenIcon());
		    } else {
			setDisabledIcon(getClosedIcon());
		    }
		}
		else {
		    setEnabled(true);
		    if (leaf) {
			setIcon(getLeafIcon());
		    } else if (expanded) {
			setIcon(getOpenIcon());
		    } else {
			setIcon(getClosedIcon());
		    }
		}
		setComponentOrientation(tree.getComponentOrientation());

		selected = sel;

		return this;
    }

    /**
      * Paints the value.  The background is filled based on selected.
      */
    public void paint(Graphics g) {
		Color bColor;
//        Graphics2D g2d = (Graphics2D)g.create();
	
	    if (isDropCell) {
	        bColor = UIManager.getColor("Tree.dropCellBackground");
	        if (bColor == null) {
	            bColor = getBackgroundSelectionColor();
	        }
	    } else if (selected) {
	        bColor = getBackgroundSelectionColor();
		} else {
		    bColor = getBackgroundNonSelectionColor();
	            if (bColor == null) {
	                bColor = getBackground();
	            }
		}
	 	int imageOffset = -1;
		
		if(bColor != null) {
			Icon currentI = getIcon();
			if(selected) {;
			    imageOffset = getLabelStart();
			    int W = getWidth() - imageOffset;
			    int H = getHeight();
			    float R = (float) Math.pow((W*W + H*H), 0.5);
		        
			    GradientPaint GP = new GradientPaint(0, 0, COLOR1, 0, getHeight(), COLOR2, true);
			    if(bufferedImage == null || bufferedImage.getHeight() != H || bufferedImage.getWidth() != W) {
			    	bufferedImage	= new BufferedImage(getWidth() - imageOffset, getHeight(), BufferedImage.TYPE_INT_ARGB);
			    	Graphics2D g2d 	= bufferedImage.createGraphics();

			    	g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
			    	g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
			    	g2d.setPaint(GP);
			    	g2d.fillRoundRect(0, 0, W - 1, H - 1, 10, 10);
			    	g2d.dispose();
			    }
			    g.drawImage(bufferedImage, imageOffset, 0, null);
			}
			else {
				//paint ground
			}
		}
	
		if (hasFocus) {
		    if (drawsFocusBorderAroundIcon) {
		    	imageOffset = 0;
		    }
		    else if (imageOffset == -1) {
		    	imageOffset = getLabelStart();
		    }
		    if(getComponentOrientation().isLeftToRight()) {
				paintFocus(g, imageOffset, 0, getWidth() - imageOffset,
					   getHeight(), bColor);
			    } else {
				paintFocus(g, 0, 0, getWidth() - imageOffset, getHeight(), bColor);
		    }
		}
		super.paint(g);
    }

    private void paintFocus(Graphics g, int x, int y, int w, int h, Color notColor) {
//		Color       bsColor = getBorderSelectionColor();
//	
//		if (bsColor != null && (selected || !drawDashedFocusIndicator)) {
//		    g.setColor(bsColor);
//		    g.drawRoundRect(x, y, w - 1, h - 1, 20 , 20);
//		}
//	        if (drawDashedFocusIndicator && notColor != null) {
//		    if (treeBGColor != notColor) {
//	                treeBGColor = notColor;
//	                focusBGColor = new Color(~notColor.getRGB());
//		    }
//		    g.setColor(focusBGColor);
//		    BasicGraphicsUtils.drawDashedRect(g, x, y, w, h);
//		}
	    GradientPaint p1 = new GradientPaint(x, y, new Color(0, 0, 0), 0, h, new Color(100, 100, 100));
	    GradientPaint p2 = new GradientPaint(x, y-1, new Color(0, 0, 0, 50), 0, h - 3, new Color(255, 255, 255, 100));

    	Graphics2D g2d 	= (Graphics2D) g.create();

    	g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    	g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));

    	g2d.setPaint(p1);
    	g2d.drawRoundRect(x, y, w - 1, h - 1, 10, 10);
    	g2d.setPaint(p2);
    	g2d.drawRoundRect(x, y-1, h - 1, h - 1, 10, 10);
    	g2d.dispose();
    }

    private int getLabelStart() {
		Icon currentI = getIcon();
		if(currentI != null && getText() != null) {
		    return currentI.getIconWidth() + Math.max(0, getIconTextGap() - 1);
		}
		return 0;
    }

    /**
     * Overrides <code>JComponent.getPreferredSize</code> to
     * return slightly wider preferred size value.
     */
    public Dimension getPreferredSize() {
		Dimension        retDimension = super.getPreferredSize();
	
		if(retDimension != null)
		    retDimension = new Dimension(retDimension.width + 3,
						 retDimension.height);
		return retDimension;
    }

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void validate() {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    *
    * @since 1.5
    */
    public void invalidate() {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void revalidate() {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void repaint(long tm, int x, int y, int width, int height) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void repaint(Rectangle r) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    *
    * @since 1.5
    */
    public void repaint() {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {	
    	// Strings get interned...
		if (propertyName == "text"
	                || ((propertyName == "font" || propertyName == "foreground")
	                    && oldValue != newValue
	                    && getClientProperty(javax.swing.plaf.basic.BasicHTML.propertyKey) != null)) {
	
		    super.firePropertyChange(propertyName, oldValue, newValue);
	    }
    }

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, byte oldValue, byte newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, char oldValue, char newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, short oldValue, short newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, int oldValue, int newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, long oldValue, long newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, float oldValue, float newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, double oldValue, double newValue) {}

   /**
    * Overridden for performance reasons.
    * See the <a href="#override">Implementation Note</a>
    * for more information.
    */
    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {}

}

